import useUserStore from '@/store/modules/user'
import * as base64 from 'js-base64'

/**getPricipalId
 * 获取项目负责人ID
 * @param {*} data  数据项
 * @param {*} idArr uuid的数组
 */
export function getPricipalId(data, idArr) {
  if (typeof idArr === 'string') {
    idArr = [idArr]
  }
  console.log(idArr)
  const result = []
  for (let i = 0; i < data.length; i++) {
    const obj = data[i]
    const uuid = obj.uuid
    let isExist = false
    for (let j = 0; j < idArr.length; j++) {
      const aj = idArr[j]
      if (uuid == aj) {
        isExist = true
        break
      }
    }
    if (isExist) {
      result.push(obj.id as never)
    }
  }
  return result
}

/**
 * 根据uuid查找符合条件的user数据，uuid不是数组的情况
 * @param data 源数据
 * @param uuid 非数组形式的uuid
 * @returns {*}
 */
export function getUniqueUserId(data, uuid) {
  console.info('data', data)
  const obj = data.find(item => item.uuid == uuid)
  if (obj) {
    return obj
  }
}

/**
 * 根据传入的参数 查找树结构数据中某个属性等于值的那条数据
 * @param data 传入的数组或者树数据 例 treeData
 * @param val 对比的值 例 1
 * @param field 对比的属性字段名 例 id
 * @param result 返回值
 * @returns {*[]}
 */
export function getTreeNodeByParam(data, val, field, result = []) {
  // console.info('data', data)
  // console.info('val', val)
  // console.info('field', field)
  data.forEach(item => {
    if (item[field] == val) {
      result.push(item as never)
      return result
    } else {
      if (item.children && item.children.length) {
        getTreeNodeByParam(item.children, val, field, result)
      }
    }
  })
  return result
}

/**
 * 跳到第一个class节点
 * @param className className默认is-error
 */
export function skipToError(className) {
  className = className || 'is-error'
  try {
    const isError = document.getElementsByClassName(className)
    isError[0].scrollIntoView({
      // 滚动到指定节点
      // 值有start,center,end，nearest，当前显示在视图区域中间
      block: 'center',
      // 值有auto、instant,smooth，缓动动画（当前是慢速的）
      behavior: 'smooth'
    })
  } catch (error) {
    console.log('错误')
  }
}

// 树形数据结构扁平化
export function flattenTree(tree, childField = 'child') {
  const result = <any>[]

  function flatten(node, childField) {
    node.forEach(item => {
      let res = JSON.parse(JSON.stringify(item)) // 先克隆一份数据作为第一层级的填充
      delete res[childField]
      result.push(res)
      if (item[childField] && item[childField].length > 0) {
        flatten(item[childField], childField)
      }
    })
  }

  flatten(tree, childField)
  return result
}

/**
 * string转array
 */
export function strToArr(val, rule = ',') {
  if (!val) return []
  if (Array.isArray(val)) return val
  if (typeof val == 'number') {
    val = val.toString()
  }
  return val.split(rule)
}

/**
 * aaa-bbb转aaaBbb
 */
export function convertToCamelCase(str) {
  // 分割字符串
  const parts = str.split('-')
  // 遍历单词数组，将每个单词（从第二个开始）的首字母转换为大写
  for (let i = 1; i < parts.length; i++) {
    const part = parts[i]
    parts[i] = part.charAt(0).toUpperCase() + part.slice(1)
  }
  // 拼接处理后的单词，形成小驼峰式字符串
  return parts.join('')
}

/**
 * 附件查看
 * @param fileUrl 附件路径
 * @param watermarkTxt 水印
 */
export function viewFile(fileUrl, watermarkTxt) {
  watermarkTxt = watermarkTxt ? watermarkTxt : '福建航信ERP文件预览'
  // const prUrl = ref(
  //   'http://192.168.1.110:9000/file/合同范本/ERP系统会议纪要2023-04-26_20230426133745A005.doc'
  // ) //要预览文件的访问地址
  // http://127.0.0.1:8012/addTask?url=http://xxx/test.txt
  window.open(
    `${
      import.meta.env.VITE_VIEW_FILE_URL
    }/onlinePreview?url=${encodeURIComponent(
      base64.encode(fileUrl)
    )}&watermarkTxt=${watermarkTxt}`
  )
}

//根据文件后缀 获取base64前缀不同 拼接完整的base64
function getBase64Type(type) {
  switch (type) {
    case 'txt':
      return 'data:text/plain;base64,'
    case 'doc':
      return 'data:application/msword;base64,'
    case 'docx':
      return 'data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64,'
    case 'xls':
      return 'data:application/vnd.ms-excel;base64,'
    case 'xlsx':
      return 'data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,'
    case 'pdf':
      return 'data:application/pdf;base64,'
    case 'pptx':
      return 'data:application/vnd.openxmlformats-officedocument.presentationml.presentation;base64,'
    case 'ppt':
      return 'data:application/vnd.ms-powerpoint;base64,'
    case 'png':
      return 'data:image/png;base64,'
    case 'jpg':
      return 'data:image/jpeg;base64,'
    case 'gif':
      return 'data:image/gif;base64,'
    case 'svg':
      return 'data:image/svg+xml;base64,'
    case 'ico':
      return 'data:image/x-icon;base64,'
    case 'bmp':
      return 'data:image/bmp;base64,'
  }
}

//将完整的base64转换为blob
function dataURLtoBlob(dataurl) {
  let arr = dataurl.split(','),
    mime = arr[0].match(/:(.*?);/)[1],
    bstr = atob(arr[1]),
    n = bstr.length,
    u8arr = new Uint8Array(n)
  while (n--) {
    u8arr[n] = bstr.charCodeAt(n)
  }
  return new Blob([u8arr], { type: mime })
}

// * desc: 下载参数入口
// * @param base64  ：返回数据的blob对象或链接
// * @param fileName  ：下载后文件名标记
function downloadFileByBase64(base64, fileName) {
  let myBlob = dataURLtoBlob(base64)
  let myUrl = URL.createObjectURL(myBlob)
  downloadFile(myUrl, fileName)
}

// * desc: 下载方法
// * @param url  ：返回数据的blob对象或链接
// * @param fileName  ：下载后文件名标记
function downloadFile(url, name) {
  console.log('url==', url)
  let a = document.createElement('a')
  a.setAttribute('href', url)
  a.setAttribute('download', name)
  a.setAttribute('target', '_blank')
  let clickEvent = document.createEvent('MouseEvents')
  clickEvent.initEvent('click', true, true)
  a.dispatchEvent(clickEvent)
}

export function base64Download(base64Type, base64Body, fileName) {
  let base64 = getBase64Type(base64Type) + base64Body
  downloadFileByBase64(base64, fileName)
}

// 金额数字转大写
export function sumToChinese(n) {
  let isLoss = false
  if (!/^(0|[1-9]\d*)(\.\d+)?$/.test(n)) {
    // 判断数据是否大于0
    // return '数据非法'
    isLoss = true
    n = n.split('-')[1]
  }

  let unit = '千百拾亿千百拾万千百拾元角分'
  let str = ''
  n += '00'
  // 如果是小数，截取小数点前面的位数
  const indexpoint = n.indexOf('.')
  if (indexpoint >= 0) {
    // 若为小数，截取需要使用的unit单位
    n = n.substring(0, indexpoint) + n.substr(indexpoint + 1, 2)
  }
  // 若为整数，截取需要使用的unit单位
  unit = unit.substr(unit.length - n.length)
  for (let i = 0; i < n.length; i++) {
    // 遍历转化为大写的数字
    str += '零壹贰叁肆伍陆柒捌玖'.charAt(n.charAt(i)) + unit.charAt(i)
  }
  let val = str
    .replace(/零(千|百|拾|角)/g, '零')
    .replace(/(零)+/g, '零')
    .replace(/零(万|亿|元)/g, '$1')
    .replace(/(亿)万|壹(拾)/g, '$1$2')
    .replace(/^元零?|零分/g, '')
    .replace(/元$/g, '元整') // 替换掉数字里面的零字符，得到结果
  return isLoss ? '(负数)' + val : val
}

// 计算属性传参可缓存
export function useComputed(fn) {
  const cache = new Map()

  function getCache(args) {
    return cache.get(JSON.stringify(args))
  }

  return function (...args) {
    const cacheResult = getCache(args)
    if (cacheResult) {
      return cacheResult
    }
    const result = computed(() => fn(...args))
    cache.set(JSON.stringify(args), result)
    return result
  }
}

/**
 * 将数字四舍五入到指定小数位，并移除结果末尾的零。
 * 如果结果以小数点结尾，也会移除该小数点。
 *
 * @param number 需要进行四舍五入的数字。
 * @param digits 指定保留的小数位数。
 * @return 返回四舍五入后的字符串，移除了末尾的零和可能的小数点。
 */
export function myToFixed(number, digits) {
  let result = number.toFixed(digits)
  while (result.endsWith('0')) {
    result = result.slice(0, -1)
  }
  if (result.endsWith('.')) {
    result = result.slice(0, -1)
  }
  return result
}

/**
 * 是否有权限
 * @param {string,Array}  字符串或数组
 * @returns {Boolean} 布尔类型
 */
export function hasPermi(val) {
  let value = strToArr(val)
  const all_permission = '*:*:*'
  const permissions = useUserStore().permissions
  if (value[0] === 'all') {
    return true
  }
  if (value && value instanceof Array && value.length > 0) {
    const permissionFlag = value

    const hasPermissions = permissions.some(permission => {
      return (
        all_permission === permission || permissionFlag.includes(permission)
      )
    })

    return hasPermissions
  } else {
    throw new Error('请设置操作权限标签值')
  }
}

/**
 * 自定义列表数据初始化
 * @param {String} tableName 列表的名称
 * @param {Array} configData 配置的列表数据
 * @returns {Array} 列表数据
 **/
export function initTable(tableName, configData) {
  const userStore = useUserStore()
  let tableCol = [] as any[]
  // 验证参数类型
  if (
    typeof tableName !== 'string' ||
    !Array.isArray(configData) ||
    configData.length === 0
  ) {
    return []
  }
  if (!userStore.userInfo.listDisaplayObj[tableName]) {
    return configData
  }

  try {
    // 安全地解析 JSON
    let _tableCol = JSON.parse(userStore.userInfo.listDisaplayObj[tableName])
    // 创建一个映射以提高查找效率
    const propToConfigMap = new Map(configData.map(item => [item.prop, item]))
    // 过滤出本地新增的列
    let initItems = configData.filter(
      item => !_tableCol.some(item1 => item1.prop === item.prop)
    )
    // 使用映射来避免多次遍历
    _tableCol.forEach(item => {
      const newItem = propToConfigMap.get(item.prop)
      if (newItem) {
        tableCol.push({ ...newItem, ...item, label: newItem.label })
      }
    })

    return [...tableCol, ...initItems]
  } catch (error) {
    console.error('Error parsing JSON:', error)
    return configData
  }

  // if (tableName && configData && configData.length > 0) {
  //   let _tableCol = JSON.parse(userStore.userInfo.listDisaplayObj[tableName])
  //   // 过滤出本地新增的列
  //   let initItmes = configData.filter(
  //     item => !_tableCol.some(item1 => item1.prop == item.prop)
  //   )
  //   tableCol = []
  //   _tableCol.forEach(item => {
  //     let newItem = {}
  //     for (const e of configData) {
  //       if (e.prop == item.prop) {
  //         newItem = { ...e, ...item, label: e.label }
  //         tableCol.push(newItem)
  //         break
  //       }
  //     }
  //   })
  //   return [...tableCol, ...initItmes]
  // }
}
